import { sendMessage } from 'webext-bridge/content-script'
import type { AuthData, AuthEventDetail } from '~/types/auth'
import { ENV } from '~/env'

// 该文件是将网页中的认证状态同步到 Background Script 中，并提供一个全局实例，用于在网页中获取当前认证状态

// 认证同步管理器
export class AuthSyncManager {
  private isInitialized = false
  private syncCallbacks: Array<(authData: AuthData | null) => void> = []

  constructor() {
    this.init()
  }

  // 初始化认证同步
  private init() {
    if (this.isInitialized)
      return

    try {
      // 如果当前站点并非配置的登录域名，则不进行初始化，避免在其他站点误触发登出
      const loginDomain = (() => {
        try {
          // 允许同时支持带协议或仅域名的配置
          const url = new URL(ENV.LOGIN_DOMAIN.startsWith('http') ? ENV.LOGIN_DOMAIN : `https://${ENV.LOGIN_DOMAIN}`)
          return url.hostname
        }
        catch {
          // 如果解析失败则直接使用原字符串
          return ENV.LOGIN_DOMAIN.replace(/^https?:\/\//, '')
        }
      })()

      if (!location.hostname.endsWith(loginDomain))
        return // 非目标站点，直接退出初始化

      // 监听来自 Web 端的认证事件
      this.setupEventListeners()

      // 页面加载时检查现有的认证状态
      this.checkInitialAuthState()

      this.isInitialized = true
    }
    catch (error) {
      console.error('❌ 认证同步管理器初始化失败:', error)
    }
  }

  // 设置事件监听器
  private setupEventListeners() {
    // 监听登录事件
    window.addEventListener('influ_watch_dog_login', (event: Event) => {
      const customEvent = event as CustomEvent<AuthEventDetail>
      this.handleAuthEvent(customEvent.detail.data)
    })

    // 监听登出事件
    window.addEventListener('influ_watch_dog_logout', (event: Event) => {
      const customEvent = event as CustomEvent<AuthEventDetail>
      this.handleAuthEvent(customEvent.detail.data)
    })

    // 监听来自 Sidepanel 的手动同步触发请求
    window.addEventListener('message', (event: MessageEvent) => {
      if (event.data && event.data.type === 'TRIGGER_AUTH_SYNC') {
        this.checkAuthFromStorage()
      }
    })

    // 监听 localStorage 变化（备用方案）
    // window.addEventListener('storage', (event) => {
    //   if (event.key === 'influ_watch_dog_auth') {
    //     console.warn('📦 localStorage 认证数据变化')
    //     this.checkAuthFromStorage()
    //   }
    // })
  }

  // 检查初始认证状态
  private checkInitialAuthState() {
    setTimeout(() => {
      this.checkAuthFromStorage()
    }, 100) // 延迟一下确保页面完全加载
  }

  // 从 localStorage 检查认证状态
  private checkAuthFromStorage() {
    try {
      const authDataStr = localStorage.getItem('influ_watch_dog_auth')
      if (authDataStr) {
        const authData: AuthData = JSON.parse(authDataStr)
        this.handleAuthEvent(authData)
      }
      else {
        this.handleAuthEvent(null)
      }
    }
    catch (error) {
      console.error('❌ 读取 localStorage 认证数据失败:', error)
      this.handleAuthEvent(null)
    }
  }

  // 处理认证事件
  private handleAuthEvent(authData: AuthData | null) {
    try {
      // 验证数据有效性
      if (authData && authData.status === 'authenticated') {
        // 检查是否过期
        if (authData.expiry && Date.now() > authData.expiry) {
          authData = null
        }
        else {
          // console.warn('✅ 认证数据有效，准备同步')
        }
      }

      // 通知所有回调函数
      this.notifyCallbacks(authData)

      // 同步到 Background Script
      this.syncToBackground(authData)
    }
    catch (error) {
      console.error('❌ 处理认证事件失败:', error)
    }
  }

  // 同步到 Background Script
  private async syncToBackground(authData: AuthData | null) {
    try {
      if (authData?.status === 'authenticated') {
        sendMessage('auth-login', authData, 'background')
      }
      else {
        await sendMessage('auth-logout', {}, 'background')
        // console.warn('✅ 登出状态已同步到 Background, 结果:', result)
      }
    }
    catch (error) {
      console.error('❌ 同步到 Background 失败:', error)
    }
  }

  // 通知所有回调函数
  private notifyCallbacks(authData: AuthData | null) {
    this.syncCallbacks.forEach((callback) => {
      try {
        callback(authData)
      }
      catch (error) {
        console.error('❌ 认证状态回调执行失败:', error)
      }
    })
  }

  // 注册认证状态变化回调
  public onAuthChange(callback: (authData: AuthData | null) => void) {
    this.syncCallbacks.push(callback)

    // 立即执行一次，提供当前状态
    this.checkAuthFromStorage()

    return () => {
      const index = this.syncCallbacks.indexOf(callback)
      if (index > -1) {
        this.syncCallbacks.splice(index, 1)
      }
    }
  }

  // 手动触发状态检查
  public triggerSync() {
    this.checkAuthFromStorage()
  }

  // 获取当前认证状态
  public getCurrentAuthData(): AuthData | null {
    try {
      const authDataStr = localStorage.getItem('influ_watch_dog_auth')
      if (!authDataStr)
        return null

      const authData: AuthData = JSON.parse(authDataStr)

      // 检查是否过期
      if (authData.expiry && Date.now() > authData.expiry) {
        localStorage.removeItem('influ_watch_dog_auth')
        return null
      }

      return authData
    }
    catch (error) {
      console.error('❌ 获取当前认证数据失败:', error)
      return null
    }
  }
}

// 创建全局实例
export const authSyncManager = new AuthSyncManager()
